home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / db / esm-3.1 / esm-3 / usr / local / sm / src / client / trans / serverTransPool.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-05  |  17.0 KB  |  699 lines
  1. #ifndef __serverTransPool_C__
  2. #define __serverTransPool_C__
  3. /*
  4.  *   $RCSfile: serverTransPool.C,v $  
  5.  *   $Revision: 1.1.1.1 $  
  6.  *   $Date: 1996/05/04 21:55:30 $      
  7.  */ 
  8. /**********************************************************************
  9. * EXODUS Database Toolkit Software
  10. * Copyright (c) 1991 Computer Sciences Department, University of
  11. *                    Wisconsin -- Madison
  12. * All Rights Reserved.
  13. *
  14. * Permission to use, copy, modify and distribute this software and its
  15. * documentation is hereby granted, provided that both the copyright
  16. * notice and this permission notice appear in all copies of the
  17. * software, derivative works or modified versions, and any portions
  18. * thereof, and that both notices appear in supporting documentation.
  19. *
  20. * THE COMPUTER SCIENCES DEPARTMENT OF THE UNIVERSITY OF WISCONSIN --
  21. * MADISON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.  
  22. * THE DEPARTMENT DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES
  23. * WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  24. *
  25. * The EXODUS Project Group requests users of this software to return 
  26. * any improvements or extensions that they make to:
  27. *
  28. *   EXODUS Project Group 
  29. *     c/o David J. DeWitt and Michael J. Carey
  30. *   Computer Sciences Department
  31. *   University of Wisconsin -- Madison
  32. *   Madison, WI 53706
  33. *
  34. *     or exodus@cs.wisc.edu
  35. *
  36. * In addition, the EXODUS Project Group requests that users grant the 
  37. * Computer Sciences Department rights to redistribute these changes.
  38. **********************************************************************/
  39.  
  40. #include "Pool.h"
  41. #include "resources.h"
  42. #include "sysdefs.h"
  43. #include "ess.h"
  44. #include "checking.h"
  45. #include "trace.h"
  46. #include "error.h"
  47. #include "io.h"
  48. #include "page.h"
  49. #include "list.h"
  50. #include "object.h"
  51. #include "pool.h"
  52. #include "tid.h"
  53. #include "bf.h"
  54. #include "chunk.h"
  55. #include "bf_macro.h"
  56. #include "lock.h"
  57. #include "scan.h"
  58. #include "load.h"
  59. #include "msgdefs.h"
  60. #include "trans.h"
  61. #include "clog.h"
  62. #include "distr.h"
  63. #include "sm_state.h"
  64. #include "serverinfo.h"
  65. #include "trans_funcs.h"
  66. #include "msg_funcs.h"
  67. #include "clog_extfuncs.h"
  68. #include "trans_globals.h"
  69. #include "bf_intfuncs.h"
  70. #include "bf_extfuncs.h"
  71. #include "fi_extfuncs.h"
  72. #include "io_extfuncs.h"
  73. #include "scan.h"
  74. #include "sm_intfuncs.h"
  75. #include "sm_globals.h"
  76.  
  77.  
  78. void 
  79. SERVERTRANSREC:: Init() {
  80.     this->ReInit();
  81.     initializeListElement( &(this->participants), this);
  82.     initializeListElement( &(this->transList),this);
  83. };
  84. void 
  85. SERVERTRANSREC:: ReInit() {
  86.     this->tid = NULL_TID;
  87.     this->serverTransState = T_INACTIVE;
  88.     this->serverInfo = NULL;
  89.     this->transRec = NULL;
  90. };
  91. LISTELEMENT *
  92. SERVERTRANSREC:: listlocation(int unique) {
  93.     TRPRINT(TR_TRANS, TR_LEVEL_1, (" ", unique));
  94.     SM_ASSERT(LEVEL_1, (unique == SERVERTRANS_POOL));
  95.     return &(this->participants);
  96. }
  97.  
  98. Pool<SERVERTRANSREC>          *serverTransPool;
  99.  
  100. void
  101. trans_Shutdown()
  102. {
  103.     delete serverTransPool;
  104.     serverTransPool = NULL;
  105.     TransRec.clientTransState = T_INACTIVE;
  106. }
  107.  
  108.  int
  109. initTrans ()
  110. {
  111.     TRACE(TR_TRANS, TR_LEVEL_1);
  112.  
  113.     TransRec.clientTid = NULL_TID;
  114.     TransRec.clientTransState = T_INACTIVE;
  115.     initializeList( &(TransRec.userDescList) );
  116.     initializeList( &(TransRec.pageHashList) );
  117.     initializeList( &(TransRec.bufGroupList) );
  118.     initializeList( &(TransRec.lockHeaderList) );
  119.     initializeList( &(TransRec.participants) );
  120.     INIT_TRANSREC_MAGIC( &TransRec );
  121.  
  122.     serverTransPool = new Pool<SERVERTRANSREC> ( "serverTrans", 
  123.         SERVERTRANS_POOL, ServerTransPoolSize, POOL_NOMORE_GETMORE );
  124.     if(serverTransPool == NULL) {
  125.         SM_ERROR(TYPE_SYS, esmMALLOCFAILED);
  126.         return esmFAILURE;
  127.     }
  128.  
  129.     /* 
  130.     serverTransPool->Stats(stderr);
  131.     */
  132.  
  133.     /* Record whether logging has been turned off for any file */
  134.     fi_MarkLoggingOff();
  135.  
  136.     /* hints are not valid between transactions */
  137.     fi_InvalidateHints();
  138.  
  139.     return esmNOERROR;
  140. }
  141.  
  142. static BOOL
  143. ClearLogTailPage( SERVERTRANSREC *stl )
  144. {
  145.     LOGINFO *logInfo = &(stl->serverInfo->logInfo);
  146.  
  147. #ifdef DEBUG
  148.     if (logInfo->tailBuffer != NULL) {
  149.         SM_ASSERT(LEVEL_1, 
  150.         (logInfo->tailBuffer->hashList.hashPid.volid == logInfo->volid));
  151.  
  152.         SM_ASSERT(LEVEL_1, PAGE_IS_CLEAN(logInfo->tailBuffer));
  153.     }
  154.     TRPRINT(TR_LOG, TR_LEVEL_1, ("LOG %d not dirty", logInfo->volid));
  155.  
  156. #endif DEBUG
  157.     logInfo->tailBuffer = NULL;
  158.  
  159.     return FALSE;
  160. }
  161.  
  162.  
  163.  
  164. SERVERTRANSREC *
  165. addTransServerInfo(
  166.     TRANSREC *transRec, 
  167.     SERVERINFO *serverInfo
  168. )
  169. {
  170.     SERVERTRANSREC *stl;
  171.  
  172.     TRPRINT(TR_TRANS, TR_LEVEL_1, 
  173.         ("Adding server %s to trans", serverInfo->hostName));
  174.  
  175.     stl = serverTransPool->Get();
  176.     stl->serverInfo = serverInfo;
  177.     stl->transRec = transRec;
  178.     transRec->numParticipants ++;
  179.     listEnq(&(transRec->participants), &(stl->participants));
  180.     listEnq(&(serverInfo->transList), &(stl->transList));
  181.  
  182.     return stl;
  183. }
  184. void
  185. removeServerTransInfo(TRANSREC *transRec, void *msg)
  186. {
  187.     MESSAGE                        *message = (MESSAGE *)msg;
  188.     SERVERTRANSREC                 *stl;
  189.  
  190.     TRPRINT(TR_TRANS, TR_LEVEL_1, ("clearing servers from trans"));
  191.  
  192.     while((stl = (SERVERTRANSREC *)listDeq(&(transRec->participants)))!=NULL) {
  193.         transRec->numParticipants --;
  194.  
  195.         if((message != NULL) && (stl->serverTransState == T_ACTIVE)) {
  196.                 TRPRINT(TR_TRANS, TR_LEVEL_1, 
  197.                     ("sending message type %d to server %s",
  198.                     message->header.type, stl->serverInfo->hostName));
  199.             message->header.params.in.tid = stl->tid;
  200.  
  201.             if (callServer(stl->serverInfo, message, NULL, 0 ) != esmNOERROR){
  202.                 /*
  203.                  *    The only way callServer could fail is if the server
  204.                  *    died, or if the transaction is already aborted.  In
  205.                  *    either case, the transaction will be aborted, so do
  206.                  *    nothing special on error
  207.                  */
  208.             }
  209.         }
  210.         /* remove this from the list of transactions considered
  211.          * active on this server
  212.          */
  213.         listRemove(&(stl->transList));
  214.         serverTransPool->Put( stl );
  215.  
  216.     }
  217.     transRec->clientTransState = T_INACTIVE;    
  218. }
  219.  
  220. void
  221. endTransForAllServers(
  222.     TRANSREC     *transRec,
  223.     int            messageType
  224. )
  225. {
  226.     MESSAGE                        message;
  227.     message.header.type = messageType;
  228.     message.header.replyRequested = TRUE;
  229.     removeServerTransInfo(transRec, &message);
  230. }
  231.  
  232.  void
  233. ForEachServerInTrans(
  234.     TRANSREC     *transRec,
  235.     int            nargs,
  236.     void        *f,
  237.     void        *arg1,
  238.     void        *arg2,
  239.     void        *arg3,
  240.     void        *arg4,
  241.     void        *arg5,
  242.     void        *arg6
  243. )
  244. {
  245.     FOREACHFUNC    func = (FOREACHFUNC)f;
  246.     SERVERTRANSREC *stl;
  247.  
  248.     TRPRINT(TR_TRANS, TR_LEVEL_1, ("sending to servers"));
  249.     SM_ASSERT(LEVEL_1, (nargs <= 7));
  250.     SM_ASSERT(LEVEL_1, (nargs >= 1));
  251.  
  252.     for(stl = (SERVERTRANSREC *)FIRST_LIST_ELEMENT(&(transRec->participants));
  253.         stl!=NULL;
  254.         stl = (SERVERTRANSREC *)NEXT_LIST_ELEMENT(&(stl->participants)) ) {
  255.  
  256.             if ((*func)(stl, arg1, arg2, arg3, arg4, arg5, arg6))
  257.                 break; /* stop looking if found */
  258.     }
  259. }
  260.  
  261.  void
  262. ForEachTrans(
  263.     int        nargs,
  264.     void    *func,
  265.     void    *arg1,
  266.     void    *arg2,
  267.     void    *arg3
  268. ) 
  269. {
  270.     TRANSREC        *transRec = findTransRec(getLocalTid());
  271.  
  272.     SM_ASSERT(LEVEL_1, (nargs <= 4));
  273.     SM_ASSERT(LEVEL_1, (nargs >= 1));
  274.  
  275.     /* TODO: go through all trans recs, using the 
  276.      * generic ForEach function, which looks at nargs, but
  277.      * passes only arg1, ... to the function.
  278.      */
  279.     (void) (*((FOREACHFUNC)func))(transRec, arg1, arg2, arg3);
  280. }
  281.  
  282.  
  283.  int
  284. commandTrans (
  285.     TRANSREC    *transRec,
  286.     COMMAND        command
  287. )
  288. {
  289.     MESSAGE            message;
  290.     int             error;
  291.     TRACE(TR_TRANS, TR_LEVEL_1);
  292.  
  293.     /*
  294.      *      We can proceed directly to make the call to the 
  295.      *      coordinator as everything else should have been
  296.      *      done at prepare time
  297.      */
  298.     message.header.replyRequested = TRUE;
  299.     message.header.type = CLIENT_COMMAND;
  300.     message.header.params.in.tid = transRec->coordTid;
  301.     message.body.command.command = command;
  302.     /*
  303.      *    TODO - mention whether logging was turned on. ??
  304.      */
  305.     /* message.body.trans.loggingOn = LogInfo.loggingOn; */
  306.  
  307.     error = callServer(transRec->coordInfo, &message, NULL, 0 );
  308.  
  309.     /*
  310.         The server's replies to a commandTrans are :
  311.             
  312.         esmTRANSDISABLED, (not done - i'm not done with recovery - 
  313.             try later)
  314.         esmBADTRANSID, (i don't know about this trans so it must
  315.             have been done already) 
  316.         esmNOTTRANSMASTER, (you can't tell me to do this so I won't - 
  317.             someone else must)
  318.         esmBADCOMMAND (i didn't understand you so it's not been done
  319.             internal error)
  320.             
  321.         esmTRANSNOTPREPARED so i ignored this commit request -
  322.             fail but don't locally do anything
  323.  
  324.         esmTRANSABORTED transaction was aborted during commit.
  325.  
  326.         esmNOERROR (abort/commit done)
  327.  
  328.         If the server got disconnected, the client code can return
  329.             esmSERVERDIED or esmNOTCONNECTED (doubtful):
  330.             assume that it was not done and retry
  331.     */
  332.  
  333.     if(error == esmNOERROR)
  334.         return esmNOERROR;
  335.         
  336.     switch(sm_errno) {
  337.  
  338.     case esmSERVERDIED:
  339.     case esmNOTCONNECTED:
  340.     case esmTRANSDISABLED:
  341.         /* might want to try again later */
  342.         break; /* failed; leave tx active */
  343.  
  344.     case esmTRANSABORTED:
  345.     case esmBADTRANSID:
  346.         return esmNOERROR;
  347.  
  348.     case esmNOTTRANSMASTER:
  349.         /* This might happen when a client crashes and a new client
  350.          * comes up to tell the coordinator to finish the tx
  351.          * TODO: We need to fix this on the server.
  352.          */
  353.         SM_ERROR(TYPE_CRASH, sm_errno);
  354.  
  355.     case esmTRANSNOTPREPARED:
  356.         break; /* failed: leave tx active */
  357.  
  358.     case esmBADCOMMAND: /* internal (protocol) error */
  359.     default: /* don't know what this situation is ! */
  360.         SM_ERROR(TYPE_FATAL, sm_errno);
  361.     }
  362.     return esmFAILURE;
  363. }
  364.  
  365. BEGIN_EXTERNC
  366. extern  void sm_EndAllIndexLoads(TID);
  367. extern  void sm_CloseAllLoadsAndScans();
  368. extern  void sm_ReleaseAllUserDesc();
  369. END_EXTERNC
  370.  
  371. static void
  372. endTrans(int how, TRANSREC *transRec)
  373. {
  374.     sm_EndAllIndexLoads(transRec->clientTid);
  375.     sm_CloseAllLoadsAndScans();
  376.     sm_ReleaseAllUserDesc();
  377.  
  378.     closeBufferGroups();
  379.     switch(how) {
  380.     /* kludge - overload the transaction states to indicate which way we are ending the tx */
  381.     case T_ABORT:
  382.         bf_FlushAll( TRUE /*2nd arg doesn't matter */ ); /* discard */
  383.         break;
  384.     case T_COMMIT:
  385.     case T_PREPARED:
  386.         clog_ForceAllLogs(transRec);
  387.         bf_FlushAll( FALSE, TRUE ); /* don't discard, skip temp vol pages */
  388.         break;
  389.     default: 
  390.         /* should not be possible */
  391.         SM_ERROR(TYPE_FATAL, esmINTERNAL);
  392.     }
  393.     ForEachServerInTrans( transRec, 1, ClearLogTailPage );
  394.  
  395. #ifdef DEBUG
  396.     if(how == T_ABORT) 
  397.         BF_AssertPageHashTableEmpty();
  398. #endif DEBUG
  399.  
  400.     /* Record whether logging has been turned off for any file */
  401.     fi_MarkLoggingOff();
  402.  
  403.     /* hints are not valid between transactions */
  404.     fi_InvalidateHints();
  405. }
  406.  
  407.  
  408.  
  409.  int
  410. commitTrans (
  411.     TRANSREC    *transRec
  412. )
  413. {
  414.     MESSAGE                        message;
  415.     SERVERINFO                    *serverInfo;
  416.     int                            error;
  417.     SERVERTRANSREC                *stl;
  418.  
  419.     TRACE(TR_TRANS, TR_LEVEL_1);
  420.  
  421.     endTrans(T_COMMIT, transRec);
  422.  
  423.     /*
  424.      *    setup the commit transaction message.
  425.      *    mention whether logging was turned on.
  426.      */
  427.     message.header.type = COMMIT_TRANS;
  428.     message.header.replyRequested = TRUE;
  429.  
  430.     if (transRec->numParticipants >= 1) {
  431.         /*
  432.          *    there can only be a single server involved
  433.          *    else, either prepareTrans or commandTrans
  434.          *    would have benn called
  435.          */
  436.         SM_ASSERT(LEVEL_1, (transRec->numParticipants == 1));
  437.  
  438.         stl = (SERVERTRANSREC *)FIRST_LIST_ELEMENT(&(transRec->participants));
  439.  
  440.         SM_ASSERT(LEVEL_1, (stl != NULL));
  441.         message.header.params.in.tid = stl->tid;
  442.         serverInfo = stl->serverInfo;
  443.  
  444.         /*
  445.          *    TODO - mention whether logging was turned on. ??
  446.          */
  447.         /* message.body.trans.loggingOn = LogInfo.loggingOn; */
  448.  
  449.         message.body.trans.syncTrans = FALSE;
  450.  
  451.         /* request server to commit the transaction */
  452.         error = callServer(serverInfo, &message, NULL, 0 );
  453.  
  454.         /*
  455.             The server's replies to a commit are :
  456.                 
  457.             esmTRANSDISABLED, (not done - i'm not done with recovery
  458.                                 - try later)
  459.             esmBADTRANSID, (i don't know about this trans so it must
  460.                 have been done already) 
  461.  
  462.             esmTRANSABORTED transaction was aborted during commit.
  463.  
  464.             esmNOTTRANSMASTER, (you can't tell me to do this so I
  465.                             won't - someone else must)
  466.             esmBADCOMMAND (i didn't understand you so it's not been
  467.                            done internal error)
  468.                 
  469.             esmTRANSNOTPREPARED so i ignored this commit request -
  470.                 fail but don't locally do anything
  471.             esmNOERROR (abort/commit done)
  472.  
  473.             If the server got disconnected, the client code can return
  474.                 esmSERVERDIED or esmNOTCONNECTED (doubtful):
  475.                 assume that it was not done and retry
  476.         */
  477.         if (error != esmNOERROR)    {
  478.             switch(sm_errno) {
  479.  
  480.             case esmSERVERDIED:
  481.             case esmNOTCONNECTED:
  482.                 /* might want to try again later */
  483.                 return esmFAILURE;
  484.  
  485.             case esmBADTRANSID:
  486.                 break; /* assume it worked; get rid of tx */
  487.  
  488.             case esmTRANSABORTED:
  489.                 break; /* it failed; keep the tx; user must abort it */
  490.  
  491.             case esmTRANSDISABLED:
  492.                 return esmFAILURE; /* failed; leave tx active */
  493.  
  494.             case esmNOTTRANSMASTER:
  495.             case esmBADCOMMAND:
  496.             case esmTRANSNOTPREPARED: /* should not happen: internal error */
  497.             default: /* don't know what this situation is ! */
  498.                 SM_ERROR(TYPE_FATAL, sm_errno);
  499.             }
  500.         }
  501.     }
  502.     removeServerTransInfo(transRec, NULL);
  503.  
  504.     transRec->clientTransState = T_INACTIVE;    
  505.     transRec->clientTid = NULL_TID;
  506.     transRec->coordTid = NULL_TID;
  507.  
  508.     return esmNOERROR;
  509. }
  510.  
  511.  int
  512. prepareTrans (
  513.     TRANSREC    *transRec,
  514.     VOTE        *vote,
  515.     BOOL        prepareAndCommit
  516. )
  517. {
  518.     MESSAGE                message;
  519.     SERVERADDRTID        serverAddrTid[MAXPARTICIPANTS];
  520.     int                    numParticipants;
  521.     SERVERTRANSREC        *stl;
  522.  
  523.     TRACE(TR_TRANS, TR_LEVEL_1);
  524.     TRPRINT(TR_SM|TR_TRANS|TR_DISTR, TR_LEVEL_1,
  525.             ("prepareTrans: transRec->numParticipants:%d", 
  526.             transRec->numParticipants));
  527.  
  528.     endTrans(T_PREPARED, transRec);
  529.  
  530.     /*
  531.      *    take care of case where we haven't yet chosen a coord
  532.      */
  533.     if (transRec->coordTid == NULL_TID) {
  534.         (void) pickCoord(transRec); /* can't return in error */
  535.     }
  536.  
  537.     /* 
  538.      *  Make sure that we're in sync with all the servers
  539.      *  (which is to say, they've got the last log pages and 
  540.      *  the last data pages).
  541.      *  Do this before we tell the coord to do anything
  542.      *  but as late as possible so that while the pages are
  543.      *  being flushed to the server, we might get something 
  544.      *  else done here.
  545.      */
  546.     io_SyncTrans(transRec, FALSE);
  547.  
  548.     /*
  549.      *    set up the prepare message for the coordinator
  550.      */
  551.     message.header.type = COORD_PREPARE_TRANS;
  552.     message.header.replyRequested = TRUE;
  553.     message.header.params.in.tid = transRec->coordTid;
  554.  
  555.     /*
  556.      *    set up the list of SERVERADDRTIDs to send with the 
  557.      *    prepare message
  558.      */
  559.     for(stl = (SERVERTRANSREC *)FIRST_LIST_ELEMENT(&(transRec->participants)),
  560.         numParticipants = 0;
  561.  
  562.         stl != NULL;
  563.         numParticipants++,
  564.         stl = (SERVERTRANSREC *)NEXT_LIST_ELEMENT(&(stl->participants))
  565.         ) {
  566.  
  567.         serverAddrTid[numParticipants].tid = stl->tid;
  568.         serverAddrTid[numParticipants].connectAddr = 
  569.             stl->serverInfo->connectAddr;
  570.     }
  571.  
  572.     SM_ASSERT(LEVEL_1, (transRec->numParticipants == numParticipants));
  573.  
  574.     message.body.prepare.numParticipants = numParticipants;
  575.     message.body.prepare.prepareAndCommit = prepareAndCommit;
  576.  
  577.     /* request server to prepare the transaction */
  578.     if (callServer(transRec->coordInfo, &message, (char *) serverAddrTid , 
  579.         numParticipants * sizeof(SERVERADDRTID))
  580.         != esmNOERROR)    {
  581.  
  582.         /*  esmTRANSDISABLED - could try again 
  583.             esmNOFREESERVERTIDINFO ditto
  584.             esmLOGDISABLED        no log; can't do it now - ditto
  585.             esmBADTRANSID        no dice: better abort
  586.             esmNOTTRANSMASTER    never : TODO FIX THIS ON SERVER
  587.             esmTOOMANYSERVERS    never: better abort
  588.             esmTRANSCOMMITTED    already committed
  589.             esmTRANSABORTED        already aborted
  590.             myriad others        no dice: better abort
  591.         */
  592.         switch(sm_errno) {
  593.         case    esmNOTCONNECTED:
  594.         case    esmSERVERDIED:
  595.         case    esmTRANSDISABLED:
  596.         case    esmNOFREESERVERTIDINFO:
  597.         case    esmLOGDISABLED:
  598.                 /* let user try again later */
  599.                 return esmFAILURE;
  600.  
  601.         case    esmTRANSCOMMITTED:
  602.                 *vote = READVOTE;
  603.                 break;
  604.         case    esmTRANSABORTED:
  605.         default:
  606.                 *vote = NOVOTE; /* kludge */
  607.                 break;
  608.         }
  609.     } else {
  610.         *vote = message.body.vote.vote;
  611.     }
  612.  
  613.     if(*vote == NOVOTE) {
  614.         /* aborted : user must do an abort  */
  615.  
  616.         transRec->clientTransState = T_ABORT;    
  617.         SM_TRANSABORTED(TYPE_USER, esmTRANSNOTPREPARED);
  618.         return esmFAILURE;
  619.  
  620.     } else if(*vote == READVOTE) {
  621.  
  622.         /* committed */
  623.         transRec->clientTransState = T_INACTIVE;    
  624.         transRec->clientTid = NULL_TID;
  625.         transRec->coordTid = NULL_TID;
  626.     }
  627.     /* a prepared tx has no reason to hang onto any of its participants info*/
  628.     removeServerTransInfo(transRec, NULL);
  629.  
  630.     return esmNOERROR;
  631. }
  632.  
  633.  int
  634. abortTrans (
  635.     TRANSREC    *transRec
  636. )
  637.  /*
  638.   *    This routine will be called only in the case of a transaction
  639.   *    which is single server and has not been prepared.
  640.   *    In case there are multiple servers, each will be contacted 
  641.   *    separately using endTransForAllServers() or through
  642.   *    the coordinator using commandTrans()
  643.   */
  644. {
  645.     TRACE(TR_TRANS, TR_LEVEL_1);
  646.  
  647.     endTrans(T_ABORT, transRec);
  648.  
  649.     endTransForAllServers(transRec, ABORT_TRANS);
  650.     transRec->clientTid = NULL_TID;
  651.     transRec->coordTid = NULL_TID;
  652.  
  653.     return esmNOERROR;
  654. }
  655.  
  656.  void
  657. ForEachTransOnServer(
  658.     SERVERINFO     *serverInfo,
  659.     int            nargs,
  660.     void        *f,
  661.     void        *arg1,
  662.     void        *arg2,
  663.     void        *arg3
  664. )
  665. {
  666.     FOREACHFUNC    func = (FOREACHFUNC)f;
  667.     SERVERTRANSREC *stl;
  668.  
  669.     SM_ASSERT(LEVEL_1, (nargs <= 4));
  670.     SM_ASSERT(LEVEL_1, (nargs >= 1));
  671.  
  672.     for(stl = (SERVERTRANSREC *)FIRST_LIST_ELEMENT(&(serverInfo->transList));
  673.         stl!=NULL;
  674.         stl = (SERVERTRANSREC *)NEXT_LIST_ELEMENT(&(stl->transList)) ) {
  675.  
  676.             if ((*func)(stl, arg1, arg2, arg3))
  677.                 /* stop looking if found */
  678.                 break;
  679.     }
  680. }
  681.  
  682. static BOOL
  683. abortTransIfMatches(SERVERTRANSREC *stl, TID tid)
  684. {
  685.     if((tid != NULL_TID) && (stl->tid != tid))
  686.         return FALSE; /* keep looking */
  687.  
  688.     CLIENT_ABORT_TRANS(stl->transRec);
  689.     return TRUE;
  690. }
  691.  
  692. void
  693. serverAbortedTrans(SERVERINFO *serverInfo, TID tid)
  694. {
  695.     ForEachTransOnServer(serverInfo, 2, abortTransIfMatches, (void *)tid, 0, 0);
  696. }
  697.  
  698. #endif __serverTransPool_C__
  699.